import ast
from typing import List, Optional, Union


# 通用节点类型检查函数
def 检查节点类型(节点, 可接受类型: Union[type, tuple], 参数名: str):
    """
    通用节点类型检查函数
    :param 节点: 要检查的节点
    :param 可接受类型: 可接受的类型或类型元组
    :param 参数名: 参数名称，用于错误提示
    :raises TypeError: 如果节点类型不符合要求
    """
    if not isinstance(节点, 可接受类型):
        可接受类型名 = ', '.join(t.__name__ for t in (可接受类型 if isinstance(可接受类型, tuple) else [可接受类型]))
        raise TypeError(f"{参数名} 必须是以下类型之一：{可接受类型名}，但收到 {type(节点).__name__}")


# 检查节点上下文是否为存储上下文

def 检查上下文是否为存储(节点):
    """
    检查节点的上下文是否为 ast.Store
    :param 节点: 要检查的节点
    :raises TypeError: 如果上下文不是 ast.Store
    """
    if not isinstance(getattr(节点, 'ctx', None), ast.Store):
        raise TypeError(f"赋值目标的上下文必须是 ast.Store，但收到 {type(getattr(节点, 'ctx', None)).__name__}")


# 创建赋值节点函数

# 创建赋值节点函数
def 创建赋值节点(赋值目标: Union[ast.AST, List[ast.AST]], 值: ast.expr) -> ast.Assign:
    """
    创建赋值节点并进行类型检查。
    :param 赋值目标: 单个或多个赋值的目标，支持 ast.Name、ast.Attribute、ast.Subscript 等。
    :param 值: 赋值的值，应为 ast.expr 类型。
    :return: ast.Assign 节点模型
    """
    可接受的目标类型 = (ast.Name, ast.Attribute, ast.Subscript, ast.Tuple, ast.List)

    if isinstance(赋值目标, 可接受的目标类型):
        赋值目标列表 = [赋值目标]
    elif isinstance(赋值目标, list):
        if not 赋值目标:
            raise ValueError("赋值目标列表不能为空。")
        赋值目标列表 = 赋值目标
    else:
        raise TypeError(f"赋值目标必须是 {', '.join(cls.__name__ for cls in 可接受的目标类型)}，但收到 {type(赋值目标).__name__}")

    for 目标 in 赋值目标列表:
        检查节点类型(目标, 可接受的目标类型, "赋值目标")
        检查上下文是否为存储(目标)

    检查节点类型(值, ast.expr, "赋值值")

    return ast.Assign(targets=赋值目标列表, value=值)


# 创建孤立表达式节点函数

def 创建孤立节点(节点: ast.expr) -> ast.Expr:
    """
    创建孤立表达式节点
    :param 节点: 表达式节点
    :return: ast.Expr 节点模型
    """
    return ast.Expr(节点)


# 创建变量节点函数

def 创建变量节点(变量名: str) -> ast.Name:
    """
    创建变量节点
    :param 变量名: 变量的名称
    :return: ast.Name 节点模型
    """
    return ast.Name(id=变量名, ctx=ast.Load())


# 创建常量节点函数

def 创建常量节点(值: Union[int, float, str, bool, None, tuple]) -> ast.Constant:
    """
    创建常量节点
    :param 值: 常量的值，可以是 int、float、str、bool、None 或 tuple
    :return: ast.Constant 节点模型
    """
    基础类型 = (int, float, str, bool, type(None), tuple)

    if not isinstance(值, 基础类型):
        raise TypeError(f"值必须是 {', '.join([t.__name__ for t in 基础类型])} 类型之一")

    return ast.Constant(value=值)


# 创建函数定义节点函数

def 创建函数节点(函数名: str, 参数列表: Optional[List[ast.arg]] = None,
                 函数体: Optional[List[ast.stmt]] = None) -> ast.FunctionDef:
    """
    创建函数定义节点
    :param 函数名: 函数名称（必需）
    :param 参数列表: 函数参数列表，包含 ast.arg 节点模型（可选）
    :param 函数体: 函数体语句列表，包含 ast.stmt 节点模型（可选）
    :return: ast.FunctionDef 节点模型
    """
    if 参数列表 is None:
        参数列表 = []
    if 函数体 is None:
        函数体 = []

    if not all(isinstance(arg, ast.arg) for arg in 参数列表):
        raise TypeError("参数列表中的每个元素必须是 ast.arg 类型")
    if not all(isinstance(stmt, ast.stmt) for stmt in 函数体):
        raise TypeError("函数体中的每个元素必须是 ast.stmt 类型")
    return ast.FunctionDef(
        name=函数名,
        args=ast.arguments(
            args=参数列表,
            vararg=None,
            kwonlyargs=[],
            kw_defaults=[],
            kwarg=None,
            defaults=[]
        ),
        body=函数体,
        decorator_list=[],
        returns=None
    )


# 创建返回节点函数

def 创建返回节点(值节点: Optional[ast.expr] = None) -> ast.Return:
    """
    创建返回节点
    :param 值节点: 返回的值，可以是任意表达式节点（可选）
    :return: ast.Return 节点模型
    """
    return ast.Return(value=值节点)


# 创建函数调用节点函数

def 创建调用节点(函数名: str, 参数列表: Optional[List[ast.expr]] = None) -> ast.Call:
    """
    创建函数调用节点
    :param 函数名: 调用的函数名（必需）
    :param 参数列表: 调用的参数列表，包含表达式节点（可选）
    :return: ast.Call 节点模型
    """
    if 参数列表 is None:
        参数列表 = []

    if not all(isinstance(arg, ast.expr) for arg in 参数列表):
        raise TypeError("参数列表中的每个元素必须是 ast.expr 类型")
    return ast.Call(
        func=创建变量节点(函数名),
        args=参数列表,
        keywords=[]
    )


# 创建类定义节点函数

def 创建类定义节点(类名: str, 基类: Optional[List[ast.expr]] = None,
                   类体: Optional[List[ast.stmt]] = None) -> ast.ClassDef:
    """
    创建类定义节点
    :param 类名: 类的名称（必需）
    :param 基类: 基类列表，包含 ast.expr 节点模型（可选）
    :param 类体: 类体语句列表，包含 ast.stmt 节点模型（可选）
    :return: ast.ClassDef 节点模型
    """
    if 基类 is None:
        基类 = []
    if 类体 is None:
        类体 = []

    if not all(isinstance(base, ast.expr) for base in 基类):
        raise TypeError("基类列表中的每个元素必须是 ast.expr 类型")
    if not all(isinstance(stmt, ast.stmt) for stmt in 类体):
        raise TypeError("类体中的每个元素必须是 ast.stmt 类型")
    return ast.ClassDef(
        name=类名,
        bases=基类,
        keywords=[],
        body=类体,
        decorator_list=[]
    )


# 创建 If 语句节点函数

def 创建条件语句节点(测试条件: ast.expr, 体: List[ast.stmt], 否则体: Optional[List[ast.stmt]] = None) -> ast.If:
    """
    创建 If 语句节点
    :param 测试条件: 条件表达式
    :param 体: 条件为真时执行的语句列表
    :param 否则体: 条件为假时执行的语句列表（可选）
    :return: ast.If 节点模型
    """
    if 否则体 is None:
        否则体 = []

    检查节点类型(测试条件, ast.expr, "测试条件")
    if not all(isinstance(stmt, ast.stmt) for stmt in 体):
        raise TypeError("体中的每个元素必须是 ast.stmt 类型")
    if not all(isinstance(stmt, ast.stmt) for stmt in 否则体):
        raise TypeError("否则体中的每个元素必须是 ast.stmt 类型")

    return ast.If(
        test=测试条件,
        body=体,
        orelse=否则体
    )


# 创建 While 循环节点函数

def 创建循环节点(测试条件: ast.expr, 体: List[ast.stmt], 否则体: Optional[List[ast.stmt]] = None) -> ast.While:
    """
    创建 While 循环ast节点基础模型
    :param 测试条件: 循环条件表达式
    :param 体: 循环体语句列表
    :param 否则体: 条件为假时执行的语句列表（可选）
    :return: ast.While 节点模型
    """
    if 否则体 is None:
        否则体 = []

    检查节点类型(测试条件, ast.expr, "测试条件")
    if not all(isinstance(stmt, ast.stmt) for stmt in 体):
        raise TypeError("体中的每个元素必须是 ast.stmt 类型")
    if not all(isinstance(stmt, ast.stmt) for stmt in 否则体):
        raise TypeError("否则体中的每个元素必须是 ast.stmt 类型")

    return ast.While(
        test=测试条件,
        body=体,
        orelse=否则体
    )


# 创建 For 循环节点函数

def 创建遍历节点(目标: ast.expr, 可迭代对象: ast.expr, 体: List[ast.stmt],
                 否则体: Optional[List[ast.stmt]] = None) -> ast.For:
    """
    创建 For 循环ast节点基础模型
    :param 目标: 循环变量
    :param 可迭代对象: 可迭代对象表达式
    :param 体: 循环体语句列表
    :param 否则体: 条件为假时执行的语句列表（可选）
    :return: ast.For 节点模型
    """
    if 否则体 is None:
        否则体 = []

    检查节点类型(目标, ast.expr, "目标")
    检查节点类型(可迭代对象, ast.expr, "可迭代对象")
    if not all(isinstance(stmt, ast.stmt) for stmt in 体):
        raise TypeError("体中的每个元素必须是 ast.stmt 类型")
    if not all(isinstance(stmt, ast.stmt) for stmt in 否则体):
        raise TypeError("否则体中的每个元素必须是 ast.stmt 类型")

    return ast.For(
        target=目标,
        iter=可迭代对象,
        body=体,
        orelse=否则体
    )
# 创建二元操作节点函数
def 创建二元操作节点(左值: ast.expr, 运算符: ast.operator, 右值: ast.expr) -> ast.BinOp:
    """
    创建二元操作节点
    :param 左值: 左操作数
    :param 运算符: 运算符节点（如 ast.Add, ast.Sub 等）
    :param 右值: 右操作数
    :return: ast.BinOp 节点模型
    """
    检查节点类型(左值, ast.expr, "左值")
    检查节点类型(右值, ast.expr, "右值")
    if not isinstance(运算符, ast.operator):
        raise TypeError("运算符必须是 ast.operator 类型")
    return ast.BinOp(left=左值, op=运算符, right=右值)

# 创建一元操作节点函数
def 创建一元操作节点(运算符: ast.unaryop, 操作数: ast.expr) -> ast.UnaryOp:
    """
    创建一元操作节点
    :param 运算符: 一元运算符节点（如 ast.UAdd, ast.USub 等）
    :param 操作数: 进行运算的表达式节点
    :return: ast.UnaryOp 节点模型
    """
    检查节点类型(操作数, ast.expr, "操作数")
    if not isinstance(运算符, ast.unaryop):
        raise TypeError("运算符必须是 ast.unaryop 类型")
    return ast.UnaryOp(op=运算符, operand=操作数)

# 创建比较节点函数
def 创建比较节点(左值: ast.expr, 运算符列表: List[ast.cmpop], 比较值列表: List[ast.expr]) -> ast.Compare:
    """
    创建比较节点
    :param 左值: 左操作数
    :param 运算符列表: 比较运算符列表（如 ast.Eq, ast.Lt 等）
    :param 比较值列表: 右操作数列表
    :return: ast.Compare 节点模型
    """
    检查节点类型(左值, ast.expr, "左值")
    if not all(isinstance(op, ast.cmpop) for op in 运算符列表):
        raise TypeError("运算符列表中的每个元素必须是 ast.cmpop 类型")
    if not all(isinstance(expr, ast.expr) for expr in 比较值列表):
        raise TypeError("比较值列表中的每个元素必须是 ast.expr 类型")
    return ast.Compare(left=左值, ops=运算符列表, comparators=比较值列表)

# 创建布尔操作节点函数
def 创建布尔操作节点(运算符: ast.boolop, 值列表: List[ast.expr]) -> ast.BoolOp:
    """
    创建布尔操作节点
    :param 运算符: 布尔运算符节点（如 ast.And, ast.Or）
    :param 值列表: 要进行布尔运算的表达式列表
    :return: ast.BoolOp 节点模型
    """
    if not isinstance(运算符, ast.boolop):
        raise TypeError("运算符必须是 ast.boolop 类型")
    if not all(isinstance(val, ast.expr) for val in 值列表):
        raise TypeError("值列表中的每个元素必须是 ast.expr 类型")
    return ast.BoolOp(op=运算符, values=值列表)

# 创建属性访问节点函数
def 创建属性访问节点(值: ast.expr, 属性名: str) -> ast.Attribute:
    """
    创建属性访问节点
    :param 值: 要访问属性的对象表达式
    :param 属性名: 属性的名称
    :return: ast.Attribute 节点模型
    """
    检查节点类型(值, ast.expr, "值")
    if not isinstance(属性名, str):
        raise TypeError("属性名必须是字符串类型")
    return ast.Attribute(value=值, attr=属性名, ctx=ast.Load())

# 创建索引节点函数
def 创建索引节点(值: ast.expr, 索引: ast.expr) -> ast.Subscript:
    """
    创建索引节点
    :param 值: 要进行索引的对象
    :param 索引: 索引表达式
    :return: ast.Subscript 节点模型
    """
    检查节点类型(值, ast.expr, "值")
    检查节点类型(索引, ast.expr, "索引")
    return ast.Subscript(value=值, slice=索引, ctx=ast.Load())

# 创建列表节点函数
def 创建列表节点(元素列表: List[ast.expr]) -> ast.List:
    """
    创建列表节点
    :param 元素列表: 列表中的元素表达式
    :return: ast.List 节点模型
    """
    if not all(isinstance(elem, ast.expr) for elem in 元素列表):
        raise TypeError("元素列表中的每个元素必须是 ast.expr 类型")
    return ast.List(elts=元素列表, ctx=ast.Load())

# 创建字典节点函数
def 创建字典节点(键列表: List[Optional[ast.expr]], 值列表: List[ast.expr]) -> ast.Dict:
    """
    创建字典节点
    :param 键列表: 字典键的表达式列表，可以为 None
    :param 值列表: 字典值的表达式列表
    :return: ast.Dict 节点模型
    """
    if not all(isinstance(key, (ast.expr, type(None))) for key in 键列表):
        raise TypeError("键列表中的每个元素必须是 ast.expr 类型或 None")
    if not all(isinstance(val, ast.expr) for val in 值列表):
        raise TypeError("值列表中的每个元素必须是 ast.expr 类型")
    if len(键列表) != len(值列表):
        raise ValueError("键列表和值列表的长度必须相等")
    return ast.Dict(keys=键列表, values=值列表)




# 创建导入自节点函数


# 创建表达式语句节点函数

def 创建表达式语句节点(表达式: ast.expr) -> ast.Expr:
    """
    创建表达式语句节点
    :param 表达式: 表达式节点
    :return: ast.Expr 节点模型
    """
    检查节点类型(表达式, ast.expr, "表达式")
    return ast.Expr(value=表达式)

# 创建断言节点函数

def 创建断言节点(测试条件: ast.expr, 消息: Optional[ast.expr] = None) -> ast.Assert:
    """
    创建断言节点
    :param 测试条件: 断言条件
    :param 消息: 如果断言失败的错误消息（可选）
    :return: ast.Assert 节点模型
    """
    检查节点类型(测试条件, ast.expr, "测试条件")
    if 消息 is not None:
        检查节点类型(消息, ast.expr, "错误消息")

    return ast.Assert(test=测试条件, msg=消息)

# 创建删除节点函数

def 创建删除节点(目标: Union[ast.expr, List[ast.expr]]) -> ast.Delete:
    """
    创建删除节点
    :param 目标: 要删除的目标，可以是单个表达式或表达式列表
    :return: ast.Delete 节点模型
    """
    if isinstance(目标, ast.expr):
        # 如果是单个目标，将其放入列表中
        目标列表 = [目标]
    elif isinstance(目标, list):
        if not 目标:
            raise ValueError("删除目标列表不能为空")
        目标列表 = 目标
    else:
        raise TypeError("目标必须是 ast.expr 类型或包含 ast.expr 的列表")

    # 确保列表中的每个目标都是 ast.expr 类型
    if not all(isinstance(target, ast.expr) for target in 目标列表):
        raise TypeError("目标列表中的每个元素必须是 ast.expr 类型")

    return ast.Delete(targets=目标列表)



def 创建全局声明节点(变量名列表: List[str]) -> ast.Global:
    """
    创建全局声明节点
    :param 变量名列表: 要声明为全局的变量名列表
    :return: ast.Global 节点模型
    """
    if not all(isinstance(var, str) for var in 变量名列表):
        raise TypeError("变量名列表中的每个元素必须是字符串类型")
    return ast.Global(names=变量名列表)


# 创建 Continue 节点函数

def 创建继续节点() -> ast.Continue:
    """
    创建 Continue 节点模型
    :return: ast.Continue 节点模型
    """
    return ast.Continue()

# 创建 Pass 节点函数

def 创建占位节点() -> ast.Pass:
    """
    创建 Pass 节点模型
    :return: ast.Pass 节点模型
    """
    return ast.Pass()




def 创建异常处理程序节点(异常类型: Optional[ast.expr], 异常名称: Optional[str],
                         处理代码块: List[ast.stmt]) -> ast.ExceptHandler:
    """
    创建异常处理程序节点
    :param 异常类型: 要捕获的异常类型（可选）
    :param 异常名称: 异常变量名称（可选）
    :param 处理代码块: 异常处理的代码块列表
    :return: ast.ExceptHandler 节点模型
    """
    if not all(isinstance(stmt, ast.stmt) for stmt in 处理代码块):
        raise TypeError("处理代码块中的每个元素必须是 ast.stmt 类型")

    return ast.ExceptHandler(type=异常类型, name=异常名称, body=处理代码块)


# 通用节点类型检查函数


# 创建 With 节点函数
def 创建上下文管理节点(上下文表达式列表: List[ast.withitem], 体: List[ast.stmt]) -> ast.With:
    """
    创建 With 节点模型
    :param 上下文表达式列表: 上下文表达式列表，包含 ast.withitem 节点模型
    :param 体: 执行的语句列表
    :return: ast.With 节点模型
    """
    if not all(isinstance(item, ast.withitem) for item in 上下文表达式列表):
        raise TypeError("上下文表达式列表中的每个元素必须是 ast.withitem 类型")
    if not all(isinstance(stmt, ast.stmt) for stmt in 体):
        raise TypeError("体中的每个元素必须是 ast.stmt 类型")
    return ast.With(
        items=上下文表达式列表,
        body=体
    )

# 创建 Try-Finally 节点函数
def 创建尝试最终节点(体: List[ast.stmt], 最终体: List[ast.stmt], 异常处理程序: Optional[List[ast.ExceptHandler]] = None) -> ast.Try:
    """
    创建 Try-Finally 节点模型
    :param 体: 尝试执行的语句列表
    :param 最终体: 最终执行的语句列表
    :param 异常处理程序: 异常处理程序列表，包含 ast.ExceptHandler 节点模型（可选）
    :return: ast.Try 节点模型
    """
    if not all(isinstance(stmt, ast.stmt) for stmt in 体):
        raise TypeError("体中的每个元素必须是 ast.stmt 类型")
    if not all(isinstance(stmt, ast.stmt) for stmt in 最终体):
        raise TypeError("最终体中的每个元素必须是 ast.stmt 类型")
    if 异常处理程序 is None:
        异常处理程序 = []
    if not all(isinstance(handler, ast.ExceptHandler) for handler in 异常处理程序):
        raise TypeError("异常处理程序中的每个元素必须是 ast.ExceptHandler 类型")
    return ast.Try(
        body=体,
        handlers=异常处理程序,
        orelse=[],
        finalbody=最终体
    )

# 创建 With Item 节点函数
def 创建上下文管理项(上下文表达式: ast.expr, 变量: Optional[ast.expr] = None) -> ast.withitem:
    """
    创建 With Item 节点模型
    :param 上下文表达式: 上下文管理表达式
    :param 变量: 可选的变量分配表达式
    :return: ast.withitem 节点模型
    """
    检查节点类型(上下文表达式, ast.expr, "上下文表达式")
    if 变量 is not None:
        检查节点类型(变量, ast.expr, "变量")
    return ast.withitem(
        context_expr=上下文表达式,
        optional_vars=变量
    )

# 创建 AugAssign 节点函数
def 创建增量赋值节点(目标: ast.expr, 运算符: ast.operator, 值: ast.expr) -> ast.AugAssign:
    """
    创建增量赋值节点
    :param 目标: 赋值目标
    :param 运算符: 增量运算符
    :param 值: 赋值的值
    :return: ast.AugAssign 节点模型
    """
    检查节点类型(目标, ast.expr, "目标")
    检查节点类型(运算符, ast.operator, "运算符")
    检查节点类型(值, ast.expr, "值")
    return ast.AugAssign(
        target=目标,
        op=运算符,
        value=值
    )

# 创建 Raise 节点函数
def 创建引发节点(异常: Optional[ast.expr] = None, 原因: Optional[ast.expr] = None) -> ast.Raise:
    """
    创建 Raise 节点模型
    :param 异常: 引发的异常表达式（可选）
    :param 原因: 引发原因（可选）
    :return: ast.Raise 节点模型
    """
    if 异常 is not None:
        检查节点类型(异常, ast.expr, "异常")
    if 原因 is not None:
        检查节点类型(原因, ast.expr, "原因")
    return ast.Raise(
        exc=异常,
        cause=原因
    )

# 创建 Yield 节点函数
def 创建生成节点(值: Optional[ast.expr] = None) -> ast.Yield:
    """
    创建 Yield 节点模型
    :param 值: 生成的值（可选）
    :return: ast.Yield 节点模型
    """
    if 值 is not None:
        检查节点类型(值, ast.expr, "值")
    return ast.Yield(
        value=值
    )

# 创建 Yield From 节点函数
def 创建生成自节点(值: ast.expr) -> ast.YieldFrom:
    """
    创建 Yield From 节点模型
    :param 值: 生成自的值
    :return: ast.YieldFrom 节点模型
    """
    检查节点类型(值, ast.expr, "值")
    return ast.YieldFrom(
        value=值
    )

# 创建 Await 节点函数
def 创建等待节点(值: ast.expr) -> ast.Await:
    """
    创建 Await 节点模型
    :param 值: 等待的表达式
    :return: ast.Await 节点模型
    """
    检查节点类型(值, ast.expr, "值")
    return ast.Await(
        value=值
    )

# 创建 Async FunctionDef 节点函数
def 创建异步函数节点(函数名: str, 参数列表: Optional[List[ast.arg]] = None, 函数体: Optional[List[ast.stmt]] = None) -> ast.AsyncFunctionDef:
    """
    创建异步函数定义节点
    :param 函数名: 函数名称（必需）
    :param 参数列表: 函数参数列表，包含 ast.arg 节点模型（可选）
    :param 函数体: 函数体语句列表，包含 ast.stmt 节点模型（可选）
    :return: ast.AsyncFunctionDef 节点模型
    """
    if 参数列表 is None:
        参数列表 = []
    if 函数体 is None:
        函数体 = []

    if not all(isinstance(arg, ast.arg) for arg in 参数列表):
        raise TypeError("参数列表中的每个元素必须是 ast.arg 类型")
    if not all(isinstance(stmt, ast.stmt) for stmt in 函数体):
        raise TypeError("函数体中的每个元素必须是 ast.stmt 类型")
    return ast.AsyncFunctionDef(
        name=函数名,
        args=ast.arguments(
            args=参数列表,
            vararg=None,
            kwonlyargs=[],
            kw_defaults=[],
            kwarg=None,
            defaults=[]
        ),
        body=函数体,
        decorator_list=[],
        returns=None
    )

# 创建 Async For 节点函数
def 创建异步遍历节点(目标: ast.expr, 可迭代对象: ast.expr, 体: List[ast.stmt], 否则体: Optional[List[ast.stmt]] = None) -> ast.AsyncFor:
    """
    创建异步 For 循环ast节点基础模型
    :param 目标: 循环变量
    :param 可迭代对象: 可迭代对象表达式
    :param 体: 循环体语句列表
    :param 否则体: 条件为假时执行的语句列表（可选）
    :return: ast.AsyncFor 节点模型
    """
    if 否则体 is None:
        否则体 = []

    检查节点类型(目标, ast.expr, "目标")
    检查节点类型(可迭代对象, ast.expr, "可迭代对象")
    if not all(isinstance(stmt, ast.stmt) for stmt in 体):
        raise TypeError("体中的每个元素必须是 ast.stmt 类型")
    if not all(isinstance(stmt, ast.stmt) for stmt in 否则体):
        raise TypeError("否则体中的每个元素必须是 ast.stmt 类型")

    return ast.AsyncFor(
        target=目标,
        iter=可迭代对象,
        body=体,
        orelse=否则体
    )

# 创建 Async With 节点函数
def 创建异步上下文管理节点(上下文表达式列表: List[ast.withitem], 体: List[ast.stmt]) -> ast.AsyncWith:
    """
    创建异步 With 节点模型
    :param 上下文表达式列表: 上下文表达式列表，包含 ast.withitem 节点模型
    :param 体: 执行的语句列表
    :return: ast.AsyncWith 节点模型
    """
    if not all(isinstance(item, ast.withitem) for item in 上下文表达式列表):
        raise TypeError("上下文表达式列表中的每个元素必须是 ast.withitem 类型")
    if not all(isinstance(stmt, ast.stmt) for stmt in 体):
        raise TypeError("体中的每个元素必须是 ast.stmt 类型")
    return ast.AsyncWith(
        items=上下文表达式列表,
        body=体
    )
# 创建二元操作节点函数

# 创建生成器表达式节点函数
def 创建生成器表达式节点(元素: ast.expr, 生成器: List[ast.comprehension]) -> ast.GeneratorExp:
    """
    创建生成器表达式节点
    :param 元素: 生成器的表达式部分
    :param 生成器: 生成器的生成部分列表
    :return: ast.GeneratorExp 节点模型
    """
    检查节点类型(元素, ast.expr, "生成器表达式元素")
    if not all(isinstance(gen, ast.comprehension) for gen in 生成器):
        raise TypeError("生成器部分的每个元素必须是 ast.comprehension 类型")
    return ast.GeneratorExp(elt=元素, generators=生成器)

# 创建列表推导式节点函数
def 创建列表推导式节点(元素: ast.expr, 生成器: List[ast.comprehension]) -> ast.ListComp:
    """
    创建列表推导式节点
    :param 元素: 列表推导式的表达式部分
    :param 生成器: 列表推导式的生成部分列表
    :return: ast.ListComp 节点模型
    """
    检查节点类型(元素, ast.expr, "列表推导式元素")
    if not all(isinstance(gen, ast.comprehension) for gen in 生成器):
        raise TypeError("生成部分的每个元素必须是 ast.comprehension 类型")
    return ast.ListComp(elt=元素, generators=生成器)

# 创建字典推导式节点函数
def 创建字典推导式节点(键: ast.expr, 值: ast.expr, 生成器: List[ast.comprehension]) -> ast.DictComp:
    """
    创建字典推导式节点
    :param 键: 字典推导式的键部分
    :param 值: 字典推导式的值部分
    :param 生成器: 字典推导式的生成部分列表
    :return: ast.DictComp 节点模型
    """
    检查节点类型(键, ast.expr, "字典推导式键")
    检查节点类型(值, ast.expr, "字典推导式值")
    if not all(isinstance(gen, ast.comprehension) for gen in 生成器):
        raise TypeError("生成部分的每个元素必须是 ast.comprehension 类型")
    return ast.DictComp(key=键, value=值, generators=生成器)

# 创建赋值表达式节点函数
def 创建赋值表达式节点(目标: ast.expr, 值: ast.expr) -> ast.NamedExpr:
    """
    创建赋值表达式节点
    :param 目标: 赋值目标
    :param 值: 赋值的值
    :return: ast.NamedExpr 节点模型
    """
    检查节点类型(目标, ast.expr, "赋值目标")
    检查节点类型(值, ast.expr, "赋值值")
    return ast.NamedExpr(target=目标, value=值)

# 创建导入节点函数
def 创建导入节点(名称列表: List[ast.alias]) -> ast.Import:
    """
    创建导入节点
    :param 名称列表: 导入的模块别名列表
    :return: ast.Import 节点模型
    """
    if not all(isinstance(名称, ast.alias) for 名称 in 名称列表):
        raise TypeError("导入的每个名称必须是 ast.alias 类型")
    return ast.Import(names=名称列表)

# 创建导入自节点函数
import ast
from typing import Optional, List, Union

def 创建导入自节点(
    模块名称: Optional[str],
    名称: Union[str, List[ast.alias]] = "*",
    别名: Optional[str] = None,
    层级: int = 0
) -> ast.ImportFrom:
    """
    创建导入自节点
    :param 模块名称: 导入的模块名称（可以为 None）
    :param 名称: 要导入的名称，可以是字符串 "*" 或 ast.alias 列表
    :param 别名: 要导入名字的别名（可选）
    :param 层级: 导入的层级
    :return: ast.ImportFrom 节点模型
    """
    if isinstance(名称, str):
        # 如果名称是字符串，则视为单个名称，并创建相应的 ast.alias
        名称列表 = [ast.alias(name=名称, asname=别名)]
    elif isinstance(名称, list):
        # 如果名称是列表，确保列表中的每个元素都是 ast.alias 类型
        if not all(isinstance(item, ast.alias) for item in 名称):
            raise TypeError("名称列表中的每个元素必须是 ast.alias 类型")
        名称列表 = 名称
    else:
        raise TypeError("名称必须是字符串或 ast.alias 列表")

    return ast.ImportFrom(module=模块名称, names=名称列表, level=层级)





def 创建非局部声明节点(变量名列表: List[str]) -> ast.Nonlocal:
    """
    创建非局部声明节点
    :param 变量名列表: 要声明为非局部的变量名列表
    :return: ast.Nonlocal 节点模型
    """
    if not all(isinstance(var, str) for var in 变量名列表):
        raise TypeError("变量名列表中的每个元素必须是字符串类型")
    return ast.Nonlocal(names=变量名列表)

# 创建中断节点函数
def 创建中断节点() -> ast.Break:
    """
    创建中断节点
    :return: ast.Break 节点模型
    """
    return ast.Break()
def 创建尝试节点(
    主代码块: List[ast.stmt],
    异常处理列表: Optional[List[ast.ExceptHandler]] = None,
    否则代码块: Optional[List[ast.stmt]] = None,
    最终代码块: Optional[List[ast.stmt]] = None
) -> ast.Try:
    """
    创建 Try 节点模型
    :param 主代码块: 要执行的主要代码块
    :param 异常处理列表: 异常处理程序列表（可选）
    :param 否则代码块: 没有异常时执行的代码块（可选）
    :param 最终代码块: 最终执行的代码块（可选）
    :return: ast.Try 节点模型
    """
    异常处理列表 = 异常处理列表 or []
    否则代码块 = 否则代码块 or []
    最终代码块 = 最终代码块 or []

    if not all(isinstance(stmt, ast.stmt) for stmt in 主代码块):
        raise TypeError("主代码块中的每个元素必须是 ast.stmt 类型")
    if not all(isinstance(handler, ast.ExceptHandler) for handler in 异常处理列表):
        raise TypeError("异常处理列表中的每个元素必须是 ast.ExceptHandler 类型")
    if not all(isinstance(stmt, ast.stmt) for stmt in 否则代码块):
        raise TypeError("否则代码块中的每个元素必须是 ast.stmt 类型")
    if not all(isinstance(stmt, ast.stmt) for stmt in 最终代码块):
        raise TypeError("最终代码块中的每个元素必须是 ast.stmt 类型")

    return ast.Try(
        body=主代码块,
        handlers=异常处理列表,
        orelse=否则代码块,
        finalbody=最终代码块
    )

# 创建打印节点函数
def 创建打印节点(值列表: List[ast.expr], 换行: bool = True) -> ast.Expr:
    """
    创建打印节点
    :param 值列表: 要打印的值列表
    :param 换行: 是否在打印后换行（默认是）
    :return: ast.Expr 节点模型
    """
    if not all(isinstance(val, ast.expr) for val in 值列表):
        raise TypeError("值列表中的每个元素必须是 ast.expr 类型")

    print_func = ast.Name(id='print', ctx=ast.Load())
    return ast.Expr(value=ast.Call(
        func=print_func,
        args=值列表,
        keywords=[ast.keyword(arg='end', value=ast.Constant(value='\n' if 换行 else ''))]
    ))


import ast
from typing import List, Optional, Union


def 创建合并节点(
    合并元素: Union[List[ast.keyword], List[ast.expr], List[Union[ast.keyword, ast.expr]]],
    值: Optional[ast.expr] = None
) -> ast.AST:
    """
    创建用于合并字典的 AST 节点模型，自动识别合并方式：
    - 如果合并元素是 ast.keyword 列表，则生成 dict(**kwargs)
    - 如果合并元素是 ast.expr 列表，则生成 dict(base, **kwargs)

    :param 合并元素: 要合并的元素列表，可以是 ast.keyword 或 ast.expr 类型
    :param 值: 要合并的基础字典或其他可迭代对象（可选）
    :return: ast.Call 节点模型
    :raises TypeError: 当合并元素类型混合或不符合预期时抛出
    """
    if not 合并元素:
        raise ValueError("合并元素列表不能为空。")

    # 检查元素是否都是 ast.keyword 或都是 ast.expr
    if all(isinstance(item, ast.keyword) for item in 合并元素):
        合并函数 = ast.Name(id='dict', ctx=ast.Load())
        return ast.Call(func=合并函数, args=[], keywords=合并元素)

    elif all(isinstance(item, ast.expr) for item in 合并元素):
        合并函数 = ast.Name(id='dict', ctx=ast.Load())
        args = [值] if 值 else [ast.Dict(keys=[], values=[])]
        keywords = [ast.keyword(arg=None, value=item) for item in 合并元素]
        return ast.Call(func=合并函数, args=args, keywords=keywords)

    else:
        raise TypeError(f"合并元素列表中的元素类型必须一致（全为 ast.keyword 或全为 ast.expr），但收到混合类型。")
# 创建格式化字符串节点函数
def 创建格式化字符串节点(字符串: str, 表达式列表: Optional[List[ast.expr]] = None) -> ast.JoinedStr:
    """
    创建格式化字符串节点
    :param 字符串: 格式化字符串文字
    :param 表达式列表: 插入的表达式列表
    :return: ast.JoinedStr 节点模型
    """
    表达式列表 = 表达式列表 or []

    if not all(isinstance(expr, ast.expr) for expr in 表达式列表):
        raise TypeError("表达式列表中的每个元素必须是 ast.expr 类型")

    parts = []
    segments = 字符串.split("{}")
    for i, segment in enumerate(segments):
        if segment:
            parts.append(ast.Constant(value=segment))
        if i < len(表达式列表):
            parts.append(表达式列表[i])

    return ast.JoinedStr(values=parts)




# 创建装饰器函数节点
def 创建装饰器节点(装饰器列表: List[ast.expr], 被装饰函数: ast.FunctionDef) -> ast.FunctionDef:
    """
    创建具有装饰器的函数节点
    :param 装饰器列表: 装饰器表达式列表
    :param 被装饰函数: 被装饰的函数节点
    :return: 带有装饰器的 ast.FunctionDef 节点模型
    """
    if not all(isinstance(decorator, ast.expr) for decorator in 装饰器列表):
        raise TypeError("装饰器列表中的每个元素必须是 ast.expr 类型")
    if not isinstance(被装饰函数, ast.FunctionDef):
        raise TypeError("被装饰函数必须是 ast.FunctionDef 类型")

    被装饰函数.decorator_list = 装饰器列表
    return 被装饰函数


# 创建模式匹配节点函数
def 创建模式匹配节点(主体: List[ast.match_case]) -> ast.Match:
    """
    创建模式匹配节点
    :param 主体: 匹配的 case 列表
    :return: ast.Match 节点模型
    """
    if not all(isinstance(case, ast.match_case) for case in 主体):
        raise TypeError("主体中的每个元素必须是 ast.match_case 类型")
    return ast.Match(cases=主体)

# 创建匹配案例节点函数
def 创建匹配案例节点(模式: ast.pattern, 体: List[ast.stmt], 条件: Optional[ast.expr] = None) -> ast.match_case:
    """
    创建匹配案例节点
    :param 模式: 匹配模式
    :param 体: 匹配成功时执行的语句列表
    :param 条件: 额外的匹配条件（可选）
    :return: ast.match_case 节点模型
    """
    检查节点类型(模式, ast.pattern, "模式")
    if not all(isinstance(stmt, ast.stmt) for stmt in 体):
        raise TypeError("体中的每个元素必须是 ast.stmt 类型")
    if 条件 is not None:
        检查节点类型(条件, ast.expr, "条件")
    return ast.match_case(pattern=模式, body=体, guard=条件)

# 创建匹配值节点函数
def 创建匹配值节点(值: ast.expr) -> ast.MatchValue:
    """
    创建匹配值节点
    :param 值: 模式匹配的值
    :return: ast.MatchValue 节点模型
    """
    检查节点类型(值, ast.expr, "值")
    return ast.MatchValue(value=值)

# 创建匹配序列节点函数
def 创建匹配序列节点(元素列表: List[ast.pattern]) -> ast.MatchSequence:
    """
    创建匹配序列节点
    :param 元素列表: 序列中的模式列表
    :return: ast.MatchSequence 节点模型
    """
    if not all(isinstance(元素, ast.pattern) for 元素 in 元素列表):
        raise TypeError("元素列表中的每个元素必须是 ast.pattern 类型")
    return ast.MatchSequence(patterns=元素列表)

def 创建匹配映射节点(键列表: List[ast.expr], 值列表: List[ast.pattern], 余值: Optional[str] = None) -> ast.MatchMapping:
    """
    创建匹配映射节点
    :param 键列表: 映射中的键表达式列表
    :param 值列表: 映射中的值模式列表
    :param 余值: 可选的余值匹配标识符
    :return: ast.MatchMapping 节点模型
    """
    if not all(isinstance(键, ast.expr) for 键 in 键列表):
        raise TypeError("键列表中的每个元素必须是 ast.expr 类型")
    if not all(isinstance(值, ast.pattern) for 值 in 值列表):
        raise TypeError("值列表中的每个元素必须是 ast.pattern 类型")
    return ast.MatchMapping(keys=键列表, patterns=值列表, rest=余值)

# 创建匹配类节点函数
def 创建匹配类节点(类名: ast.expr, 参数列表: List[ast.pattern], 关键词参数列表: Optional[List[ast.keyword]] = None) -> ast.MatchClass:
    """
    创建匹配类节点
    :param 类名: 类名表达式
    :param 参数列表: 位置参数模式列表
    :param 关键词参数列表: 关键词参数列表（可选）
    :return: ast.MatchClass 节点模型
    """
    检查节点类型(类名, ast.expr, "类名")
    if not all(isinstance(参数, ast.pattern) for 参数 in 参数列表):
        raise TypeError("参数列表中的每个元素必须是 ast.pattern 类型")
    if 关键词参数列表 is not None:
        if not all(isinstance(关键词参数, ast.keyword) for 关键词参数 in 关键词参数列表):
            raise TypeError("关键词参数列表中的每个元素必须是 ast.keyword 类型")
    return ast.MatchClass(cls=类名, patterns=参数列表, kwd_attrs=[], kwd_patterns=关键词参数列表 or [])

# 创建匹配或节点函数
def 创建匹配或节点(模式列表: List[ast.pattern]) -> ast.MatchOr:
    """
    创建匹配或节点
    :param 模式列表: 或模式列表
    :return: ast.MatchOr 节点模型
    """
    if not all(isinstance(模式, ast.pattern) for 模式 in 模式列表):
        raise TypeError("模式列表中的每个元素必须是 ast.pattern 类型")
    return ast.MatchOr(patterns=模式列表)
# 创建匹配星号节点函数
def 创建匹配星号节点(模式: Optional[ast.pattern] = None) -> ast.MatchStar:
    """
    创建匹配星号节点
    :param 模式: 匹配的模式（可选）
    :return: ast.MatchStar 节点模型
    """
    if 模式 is not None:
        if not isinstance(模式, ast.pattern):
            raise TypeError("模式必须是 ast.pattern 类型")
    return ast.MatchStar(name=模式)

# 创建匹配关键字节点函数
def 创建匹配关键字节点(参数名: str, 模式: ast.pattern) -> ast.MatchAs:
    """
    创建匹配关键字节点
    :param 参数名: 匹配的参数名
    :param 模式: 匹配的模式
    :return: ast.MatchAs 节点模型
    """
    if not isinstance(参数名, str):
        raise TypeError("参数名必须是字符串类型")
    if not isinstance(模式, ast.pattern):
        raise TypeError("模式必须是 ast.pattern 类型")
    return ast.MatchAs(name=参数名, pattern=模式)



# 创建模式绑定节点函数
def 创建模式绑定节点(名称: str) -> ast.MatchAs:
    """
    创建模式绑定节点
    :param 名称: 绑定的名称
    :return: ast.MatchAs 节点模型
    """
    if not isinstance(名称, str):
        raise TypeError("名称必须是字符串类型")
    return ast.MatchAs(name=名称)

# 创建匹配常量节点函数
def 创建匹配常量节点(常量值: Union[str, int, float, bool, None]) -> ast.MatchValue:
    """
    创建匹配常量节点
    :param 常量值: 要匹配的常量值，可以是字符串、整数、浮点数、布尔值或 None
    :return: ast.MatchValue 节点模型
    """
    return ast.MatchValue(value=ast.Constant(value=常量值))

# 创建匹配名节点函数
def 创建匹配名节点(名称: str) -> ast.MatchAs:
    """
    创建匹配名节点
    :param 名称: 匹配的名称
    :return: ast.MatchAs 节点模型
    """
    if not isinstance(名称, str):
        raise TypeError("名称必须是字符串类型")
    return ast.MatchAs(name=名称)

# 创建匿名函数节点函数
def 创建匿名函数节点(参数: ast.arguments, 函数体: ast.expr) -> ast.Lambda:
    """
    创建匿名函数节点
    :param 参数: 函数的参数列表
    :param 函数体: 函数体表达式
    :return: ast.Lambda 节点模型
    """
    return ast.Lambda(args=参数, body=函数体)

# 创建扩展切片节点函数（改为使用 ast.Tuple）
def 创建扩展切片节点(切片列表: List[Union[ast.slice, ast.Index]]) -> ast.ExtSlice:
    """
    创建扩展切片节点（用于多维切片）
    :param 切片列表: 切片列表
    :return: ast.ExtSlice 节点模型
    """
    return ast.ExtSlice(dims=切片列表)

# 创建集合节点函数
def 创建集合节点(元素列表: List[ast.expr]) -> ast.Set:
    """
    创建集合节点
    :param 元素列表: 集合的元素表达式列表
    :return: ast.Set 节点模型
    """
    return ast.Set(elts=元素列表)

# 创建集合推导式节点函数
def 创建集合推导式节点(元素: ast.expr, 生成器: List[ast.comprehension]) -> ast.SetComp:
    """
    创建集合推导式节点
    :param 元素: 集合推导式的元素部分
    :param 生成器: 集合推导式的生成部分列表
    :return: ast.SetComp 节点模型
    """
    return ast.SetComp(elt=元素, generators=生成器)

# 创建星号表达式节点函数
def 创建星号表达式节点(值: ast.expr, 上下文: ast.expr_context) -> ast.Starred:
    """
    创建星号表达式节点
    :param 值: 表达式的值
    :param 上下文: 上下文信息（加载或存储）
    :return: ast.Starred 节点模型
    """
    return ast.Starred(value=值, ctx=上下文)


# 创建函数参数列表节点函数
def 创建函数参数列表节点(参数: List[ast.arg], 可变参数: Optional[ast.arg] = None, 关键字参数: Optional[ast.arg] = None) -> ast.arguments:
    """
    创建函数的参数列表节点
    :param 参数: 位置参数列表
    :param 可变参数: 可变参数（可选）
    :param 关键字参数: 关键字参数（可选）
    :return: ast.arguments 节点模型
    """
    return ast.arguments(args=参数, vararg=可变参数, kwonlyargs=[], kw_defaults=[], kwarg=关键字参数, defaults=[])

# 创建关键字参数节点函数
def 创建关键字参数节点(参数名: str, 值: ast.expr) -> ast.keyword:
    """
    创建关键字参数节点
    :param 参数名: 关键字参数的名称
    :param 值: 参数对应的值
    :return: ast.keyword 节点模型
    """
    return ast.keyword(arg=参数名, value=值)

# 创建函数参数节点函数
def 创建函数参数节点(参数名: str, 注释: Optional[ast.expr] = None) -> ast.arg:
    """
    创建函数参数节点
    :param 参数名: 参数名称
    :param 注释: 参数注释（可选）
    :return: ast.arg 节点模型
    """
    return ast.arg(arg=参数名, annotation=注释)

# 创建 f-string 格式化值节点函数
def 创建格式化值节点(值: ast.expr, 转换: Optional[int] = -1, 格式说明: Optional[ast.expr] = None) -> ast.FormattedValue:
    """
    创建 f-string 格式化值节点
    :param 值: 要格式化的值
    :param 转换: 格式转换标志
    :param 格式说明: 格式说明表达式（可选）
    :return: ast.FormattedValue 节点模型
    """
    return ast.FormattedValue(value=值, conversion=转换, format_spec=格式说明)


# 创建条件表达式节点函数
def 创建条件表达式节点(测试条件: ast.expr, 真值: ast.expr, 假值: ast.expr) -> ast.IfExp:
    """
    创建条件表达式节点
    :param 测试条件: 测试条件表达式
    :param 真值: 条件为真时的结果表达式
    :param 假值: 条件为假时的结果表达式
    :return: ast.IfExp 节点模型
    """
    # 检查每个参数是否为表达式节点
    for 参数, 名称 in zip([测试条件, 真值, 假值], ["测试条件", "真值", "假值"]):
        if not isinstance(参数, ast.expr):
            raise TypeError(f"{名称} 必须是 ast.expr 类型，但收到 {type(参数).__name__}")

    return ast.IfExp(test=测试条件, body=真值, orelse=假值)


# 创建元组节点函数
def 创建元组节点(元素列表: List[ast.expr]) -> ast.Tuple:
    """
    创建元组节点
    :param 元素列表: 元组中的元素表达式列表
    :return: ast.Tuple 节点模型
    """
    # 检查每个元素是否为表达式节点
    if not all(isinstance(元素, ast.expr) for 元素 in 元素列表):
        raise TypeError("元素列表中的每个元素必须是 ast.expr 类型")

    return ast.Tuple(elts=元素列表, ctx=ast.Load())
# 创建注解赋值节点函数
# def 创建注解赋值节点(目标: ast.expr, 注解: ast.expr, 值: Optional[ast.expr] = None, 简单: int = 1) -> ast.AnnAssign:
#     """
#     创建注解赋值节点
#     :param 目标: 赋值目标，应该是一个表达式节点
#     :param 注解: 类型注解，应该是一个表达式节点
#     :param 值: 要赋的值，可以是一个表达式节点（可选）
#     :param 简单: 表示是否为简单的赋值（默认为 1）
#     :return: ast.AnnAssign 节点模型
#     """
#
#     检查节点类型(目标, ast.expr, "目标")
#     检查节点类型(注解, ast.expr, "注解")
#     if 值 is not None:
#         检查节点类型(值, ast.expr, "值")
#     return ast.AnnAssign(
#         target=目标,
#         annotation=注解,
#         value=值,
#         simple=简单
#     )
def 创建注解节点(目标: ast.expr, 注解: ast.expr, 简单: int = 1) -> ast.AnnAssign:
    """
    创建注解赋值节点
    :param 目标: 赋值目标，应该是一个表达式节点
    :param 注解: 类型注解，应该是一个表达式节点
    :param 值: 要赋的值，可以是一个表达式节点（可选）
    :param 简单: 表示是否为简单的赋值（默认为 1）
    :return: ast.AnnAssign 节点模型
    """
    检查节点类型(目标, ast.expr, "目标")
    检查节点类型(注解, ast.expr, "注解")

    return ast.AnnAssign(
        target=目标,
        annotation=注解,
        simple=简单
    )

# 创建多重异常处理尝试节点函数
def 创建多重异常处理尝试节点(主体代码: List[ast.stmt], 异常处理程序: Optional[List[ast.ExceptHandler]] = None,
             否则代码: Optional[List[ast.stmt]] = None, 最终代码: Optional[List[ast.stmt]] = None) -> ast.TryStar:
    """
    创建多重异常处理尝试节点
    :param 主体代码: 要执行的主体代码
    :param 异常处理程序: 异常处理程序列表（可选）
    :param 否则代码: 没有异常时执行的代码列表（可选）
    :param 最终代码: 最终执行的代码列表（可选）
    :return: ast.TryStar 节点模型
    """
    if 异常处理程序 is None:
        异常处理程序 = []
    if 否则代码 is None:
        否则代码 = []
    if 最终代码 is None:
        最终代码 = []

    if not all(isinstance(stmt, ast.stmt) for stmt in 主体代码):
        raise TypeError("主体代码中的每个元素必须是 ast.stmt 类型")
    if not all(isinstance(handler, ast.ExceptHandler) for handler in 异常处理程序):
        raise TypeError("异常处理程序中的每个元素必须是 ast.ExceptHandler 类型")
    if not all(isinstance(stmt, ast.stmt) for stmt in 否则代码):
        raise TypeError("否则代码中的每个元素必须是 ast.stmt 类型")
    if not all(isinstance(stmt, ast.stmt) for stmt in 最终代码):
        raise TypeError("最终代码中的每个元素必须是 ast.stmt 类型")

    return ast.TryStar(
        body=主体代码,
        handlers=异常处理程序,
        orelse=否则代码,
        finalbody=最终代码
    )

# 创建交互式模式节点函数
def 创建交互式模式节点(主体代码: List[ast.stmt]) -> ast.Interactive:
    """
    创建交互式模式节点
    :param 主体代码: 交互式模式中的主体代码列表
    :return: ast.Interactive 节点模型
    """
    if not all(isinstance(stmt, ast.stmt) for stmt in 主体代码):
        raise TypeError("主体代码中的每个元素必须是 ast.stmt 类型")
    return ast.Interactive(body=主体代码)

# 创建模块节点函数
def 创建模块节点(主体代码: List[ast.stmt], 类型忽略: Optional[List[ast.TypeIgnore]] = None) -> ast.Module:
    """
    创建模块节点
    :param 主体代码: 模块中的主体代码列表
    :param 类型忽略: 类型忽略列表（可选）
    :return: ast.Module 节点模型
    """
    if 类型忽略 is None:
        类型忽略 = []
    if not all(isinstance(stmt, ast.stmt) for stmt in 主体代码):
        raise TypeError("主体代码中的每个元素必须是 ast.stmt 类型")
    if not all(isinstance(ignore, ast.TypeIgnore) for ignore in 类型忽略):
        raise TypeError("类型忽略中的每个元素必须是 ast.TypeIgnore 类型")
    return ast.Module(body=主体代码, type_ignores=类型忽略)

# 创建表达式模块节点函数
def 创建表达式模块节点(表达式: ast.expr) -> ast.Expression:
    """
    创建表达式模块节点
    :param 表达式: 表达式节点
    :return: ast.Expression 节点模型
    """
    检查节点类型(表达式, ast.expr, "表达式")
    return ast.Expression(body=表达式)

# 创建函数类型节点函数
def 创建函数类型节点(参数类型: List[ast.expr], 返回类型: ast.expr) -> ast.FunctionType:
    """
    创建函数类型节点
    :param 参数类型: 函数参数类型列表
    :param 返回类型: 函数返回类型
    :return: ast.FunctionType 节点模型
    """
    if not all(isinstance(arg, ast.expr) for arg in 参数类型):
        raise TypeError("参数类型中的每个元素必须是 ast.expr 类型")
    检查节点类型(返回类型, ast.expr, "返回类型")
    return ast.FunctionType(argtypes=参数类型, returns=返回类型)


# 创建切片节点函数（支持复杂索引）
def 创建切片节点(下界: Optional[ast.expr] = None, 上界: Optional[ast.expr] = None, 步长: Optional[ast.expr] = None) -> ast.Slice:
    """
    创建切片节点
    :param 下界: 切片的下界（可选）
    :param 上界: 切片的上界（可选）
    :param 步长: 切片的步长（可选）
    :return: ast.Slice 节点模型
    """
    if 下界 is not None:
        检查节点类型(下界, ast.expr, "下界")
    if 上界 is not None:
        检查节点类型(上界, ast.expr, "上界")
    if 步长 is not None:
        检查节点类型(步长, ast.expr, "步长")
    return ast.Slice(lower=下界, upper=上界, step=步长)

# 创建推导式生成器部分节点函数
def 创建推导式生成器部分(目标: ast.expr, 可迭代对象: ast.expr, 条件列表: Optional[List[ast.expr]] = None, 异步: int = 0) -> ast.comprehension:
    """
    创建推导式生成器部分节点
    :param 目标: 推导式的目标变量
    :param 可迭代对象: 可迭代对象表达式
    :param 条件列表: 推导式中的条件列表（可选）
    :param 异步: 是否为异步生成器（0 表示否，1 表示是）
    :return: ast.comprehension 节点模型
    """
    检查节点类型(目标, ast.expr, "目标")
    检查节点类型(可迭代对象, ast.expr, "可迭代对象")
    if 条件列表 is None:
        条件列表 = []
    if not all(isinstance(cond, ast.expr) for cond in 条件列表):
        raise TypeError("条件列表中的每个元素必须是 ast.expr 类型")
    return ast.comprehension(target=目标, iter=可迭代对象, ifs=条件列表, is_async=异步)

# 创建忽略类型检查节点函数
def 创建忽略类型检查节点(行号: int, 标签: str) -> ast.TypeIgnore:
    """
    创建忽略类型检查节点
    :param 行号: 忽略类型检查的行号
    :param 标签: 类型忽略的标签
    :return: ast.TypeIgnore 节点模型
    """
    if not isinstance(行号, int):
        raise TypeError("行号必须是 int 类型")
    if not isinstance(标签, str):
        raise TypeError("标签必须是字符串类型")
    return ast.TypeIgnore(lineno=行号, tag=标签)
# 创建模式匹配单例节点函数
def 创建模式匹配单例节点(值: ast.Constant) -> ast.MatchSingleton:
    """
    创建模式匹配单例节点
    :param 值: 要匹配的单例值（例如 None）
    :return: ast.MatchSingleton 节点模型
    """
    检查节点类型(值, ast.Constant, "值")
    return ast.MatchSingleton(value=值)

# 创建模式匹配命名捕获节点函数
def 创建模式匹配命名捕获节点(模式: Optional[ast.pattern] = None, 名称: Optional[str] = None) -> ast.MatchAs:
    """
    创建模式匹配命名捕获节点
    :param 模式: 匹配的模式（可选）
    :param 名称: 捕获的变量名称（可选）
    :return: ast.MatchAs 节点模型
    """
    if 模式 is not None:
        检查节点类型(模式, ast.pattern, "模式")
    if 名称 is not None and not isinstance(名称, str):
        raise TypeError("名称必须是字符串类型")
    return ast.MatchAs(pattern=模式, name=名称)
